package com.example.demo.service.impl;

import com.example.demo.enity.Bill;
import com.example.demo.mapper.BillListMapper;
import com.example.demo.service.BillListService;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.jws.Oneway;
import java.util.ArrayList;
import java.util.List;

//创建一个接口的实例化对象 实现BillListService接口

@Service
public class BillListServiceimpl implements BillListService {

    @Autowired
    BillListMapper billListMapper;

    @Autowired
    RedisTemplate redisTemplate;


    @Override
    public List<Bill> getList(Object object) {
        List<Bill> billList = billListMapper.getBillListByWhere((Bill) object);
        return billList;
    }

    @Override
    public int addObject(Object object) {
        int i = billListMapper.billAddMapper((Bill) object);
        redisTemplate.opsForValue().set("bills", billListMapper.getBillListByWhere(null));
        return i;
    }

    @Override
    public int updateObject(Object object) {

        int i = billListMapper.updateBillByBill((Bill) object);

        ObjectMapper objectMapper = new ObjectMapper();
        Bill bill = objectMapper.convertValue(object, Bill.class);

        Integer billId = bill.getBillId();

        redisTemplate.opsForValue().set("bill" + billId, bill);
        redisTemplate.opsForValue().set("bills", billListMapper.getBillListByWhere(null));

        return i;
    }


//    @Override
//    public PageInfo findByWhere(Bill bill, Integer pageNum) {

    //缓存的书写位置：Service层中的实现类中
    //原因：缓存说到底处理的是业务逻辑
    //如果写在层 就会在C层（处理Java逻辑）处理大量逻辑 会显得整体头重脚轻
    //这就是为什么要添加一个Service层的原因（处理业务逻辑）

    //判断一下缓存中有没有我们需要的东西
    //有：直接从缓存中获得
    //没有：从数据库中拿到然后再放入缓存中，最后再通过V层访问缓存
    //原因：减少V层直接访问数据库的次数，提高运行速度

//        List<Bill> o = (List<Bill>) redisTemplate.opsForValue().get("billList"+ pageNum);
////        ObjectMapper objectMapper = new ObjectMapper();
//        List<Bill> list = objectMapper.convertValue(o, new TypeReference<List<Bill>>() {
//        });
//        return list;

//    }


    @Override
    public Bill findById(Integer billId) {

        //判断一下缓存中有没有我们需要的东西
        //有：直接从缓存中获得
        //没有：从数据库中拿到然后再放入缓存中，最后再通过V层访问缓存
        //原因：减少V层直接访问数据库的次数，提高运行速度

        ObjectMapper objectMapper = new ObjectMapper();
        Bill bill = objectMapper.convertValue(redisTemplate.opsForValue().get("bill" + billId), Bill.class);
        if (bill == null) {
            redisTemplate.opsForValue().set("bill" + billId, billListMapper.findById(billId));
        }
        Object object = redisTemplate.opsForValue().get("bill" + billId);
        Bill result = objectMapper.convertValue(object, Bill.class);
        return result;
    }


//    @Override
//    public int BillAddMapper(Bill bill) {
//
//        //先更改数据库（以数据库为主）
//        //然后再根据需要更改缓存中的内容
//
//        int i = billListMapper.BillAddMapper(bill);
//        redisTemplate.opsForValue().set("bills", billListMapper.getBillListByWhere(null));
//        return i;
//    }


    @Override
    public int remove(Integer billId) {

        //先更改数据库（以数据库为主）
        //然后再根据需要更改缓存中的内容

        int i = billListMapper.remove(billId);
        redisTemplate.delete("bill" + billId);
        redisTemplate.opsForValue().set("bills", billListMapper.getBillListByWhere(null));
        return i;
    }


}
